package com.seven.commons;

import com.google.common.collect.*;

import java.util.*;

import static java.util.stream.Collectors.toList;

/**
 * @author sevenDay
 * @classname SevenCollectionUtils
 * @description: guava的集合的封装类的实现
 * @date 2018/1/12
 */
public class SevenCollectionUtils {

    /**
     * 创建组成集合元素的
     * @param elements 元素
     * @param <E> 元素的类型
     * @return
     */
    public static <E> ArrayList<E> newArrayList(E... elements) {
        return Lists.newArrayList(elements);
    }

    /**
     * 反转元素集合
     * @param list 反转的集合
     * @param <T> 集合元素的类型
     * @return
     */
    public static <T> List<T> reverse(List<T> list){
        return Lists.reverse(list);
    }

    /**
     * 将元素分为两组
     * @param list 集合元素
     * @param size 分成的组数
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> partition(List<T> list, int size){

        return Lists.partition(list,size);
    }

    /**
     * 按照某种类型或者实现的方法进行过滤集合中的元素
     * @param list
     * @param function
     * @param <T>
     * @return
     */
    public static <T> List<T> filter(List<T> list, Function<T>  function){

        final ImmutableList<T> ts = FluentIterable.from(list).filter(function).toList();

        return ts;

    }

    /**
     * 将集合中的元素按照某种方式进行转换为新的集合元素类型
     * @param list 集合元素
     * @param transFormFunction 转换函数
     * @param <P> 之前的元素类型
     * @param <L> 之后转换的元素类型
     * @return
     */
    public static <P,L> List<L> transform(List<P> list,TransFormFunction<P,L> transFormFunction){

        return FluentIterable.from(list).transform(transFormFunction).toList();
    }

    /**
     * 创建set集合元素
     * @param elements
     * @param <T>
     * @return
     */
    public static <T> Set<T> newHashSet(T... elements){

        return Sets.newHashSet(elements);
    }

    /**
     * 创建不可变的K,V组成迭代的Map的集合
     * k1 ,k2,k3,k4......v1,v2,v3,v4......
     * @param k1
     * @param v1
     * @param k2
     * @param v2
     * @param <K> K类型
     * @param <V> V类型
     * @return
     */
    public static <K, V> Map<K,V> createImmutableMap(K k1, V v1, K k2, V v2) {

     return ImmutableMap.of( k1,v1,k2,v2);

    }

    /**
     * 创建重复的key对应多个key的值，用法和Map类似
     * @param k 传递的 key
     * @param elements 多个value
     * @param <K> K类型
     * @param <V> V类型
     * @return
     */
    public static <K, V> Multimap<K, V> createRepeatKeyMap(K k,V... elements){
        final ArrayListMultimap<K, V> multimapKey = ArrayListMultimap.create();
        for (V v:elements){
            multimapKey.put(k,v);
        }
        return multimapKey;
    }

    /**
     * 创建可以重复的set的集合
     * multiSet.count(30)获取重复元素的值
     * @param t 添加到set的集合
     * @param <T> T类型
     * @return
     */
    public static <T> Multiset<T> createMultiSet( T...  t){
        Multiset<T> multiSet = HashMultiset.create();
        for (T v:t){
            multiSet.add(v);
        }
        return multiSet;
    }

    /**
     * 进行key value的map的创建，可以根据key得到value可根据value得到key
     * demo： biMap.inverse().get("test");
     * @param k
     * @param v
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> BiMap<K,V> createMultiSet(K k,V v){
        BiMap<K,V> bitMap = HashBiMap.create();
        bitMap.put(k,v);
        return bitMap;
    }

    /**
     * 针对集合排序默认从小到达
     * @param list 排序的集合
     * @param <E> 排序的元素类型
     * @return
     */
    public static <E  extends  Comparable<?> > List<E> sortMinToMaxList(Iterable<E> list){

       return  Ordering.natural().sortedCopy(list);

    }
    /**
     * 针对集合排序默认从大到小
     * @param list 排序的集合
     * @param <E> 排序的元素类型
     * @return
     */
    public static <E  extends  Comparable<?> > List<E> sortMaxTominList(Iterable<E> list){

        return  Ordering.natural().reverse().sortedCopy(list);

    }

    /**
     * 将list中的对象转化为Map的集合类型，其中V类型的属性必须唯一，否则报错
     * @param list list集合
     * @param function 转化 函数
     * @param <K> K类型
     * @param <V>V类型的数据
     * @return
     */
    public static <K,V> Map<K,V> listTransformMap(List<V> list,TransFormFunction<V,K> function){

       return  Maps.uniqueIndex(list, function);
    }

    /**
     * 去除重复的集合的元素
     * @param list
     * @param <E>
     * @return
     */
    public static <E> List<E> distinctCollection(Iterable<E> list){

        return Lists.newArrayList(Sets.newHashSet(list));

    }
    /**
     * @descrp:list转化为set
     * @auther: Xiaohong
     * @date: 2019/3/21 13:53
     * @param list :
     * @return : java.util.Set<E>
     */
    public static <E> Set<E> listToSet(List<E> list){

        return new HashSet(list);
    }
    /**
     * @descrp:set to list
     * @auther: Xiaohong
     * @date: 2019/3/21 13:54
     * @param set :
     * @return : java.util.List<E>
     */

    public static <E> List<E> setToList(Set<E> set){

        return  Lists.newArrayList(set);
    }
    /**
     * @descrp:array转化为list
     * @auther: Xiaohong
     * @date: 2019/3/21 14:32
     * @param a :
     * @return : java.util.List<E>
     */
    public static <E> List<E> arrayToList(E[] a){


        return   Arrays.asList(a);
    }
    /**
     * @descrp:数组转化为set操作
     * @auther: Xiaohong
     * @date: 2019/3/21 14:35
     * @param a :
     * @return : java.util.Set<E>
     */
    public static <E> Set<E> arrayToSet(E[] a){


        return  listToSet(Arrays.asList(a));
    }
    /**
     * @descrp:value转化为数组
     * @auther: Xiaohong
     * @date: 2019/3/21 14:40
     * @param map :
     * @return : java.util.List<V>
     */
    public static <K,V> List<V> mapValueToList(Map<K,V> map){

        return  Lists.newArrayList(map.values());
    }
    /**
     * @descrp:key转化为数组
     * @auther: Xiaohong
     * @date: 2019/3/21 14:40
     * @param map :
     * @return : java.util.List<V>
     */
    public static <K,V> List<K> mapKeyToList(Map<K,V> map){


        return  setToList(map.keySet());
    }
    /**
     * @descrp:list转化为数组
     * @auther: Xiaohong
     * @date: 2019/3/21 14:45
     * @param list :
     * @return : E[]
     */
    public static <E> E[] listToArray(List<E> list){


        return  (E[])list.toArray();
    }
}
